home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / libs / sphigs / sph_mac.hqx / SRGP port to 5.0 (compressed) / SRGP_SPHIGS Root / MacSRGP / srgp_canvas.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-02-13  |  6.6 KB  |  269 lines
  1. #include "HEADERS.h"
  2. #include "srgplocal.h"
  3.  
  4. #ifdef THINK_C
  5. #include "ChooseWhichQuickDraw.h"
  6. #endif
  7.  
  8. #include "srgp_canvas.proto.h"
  9.  
  10. /** ABOUT CANVASES
  11. At any given time, there is one ACTIVE canvas.
  12.  
  13. The ACTIVE canvas is the one affected by all output primitives.
  14.  
  15. Initially, canvas #0 is the only canvas; it is always visible and
  16.    is the size of the screen.  Its coordinate system is the
  17.    one involved in all input commands.
  18.  
  19. The permanent spec for each canvas is stored in a
  20.    table (srgp__canvasTable).
  21. But the spec for the currently active canvas is
  22.    stored in a cache (srgp__curActiveCanvasSpec) and sometimes
  23.    is more current than the permanent version.
  24. **/
  25.    
  26.  
  27.  
  28.  
  29. /** INTERNAL: setting canvas defaults
  30. Sets the defaults for the currently active canvas.
  31. Affects the cache (srgp__curActiveCanvasSpec) first.
  32. Then copies into the permanent table.
  33. Assumes that "max_coord" fields are already set.
  34. **/
  35.  
  36. void
  37. SRGP__setCanvasDefaults (void)
  38. {
  39.    PUSH_TRACE;
  40.  
  41.    /* Fool the attribute routines so they *have* to do the work. */
  42.    memset (&srgp__curActiveCanvasSpec.attributes, -1, 
  43.        sizeof(srgp__attribute_group));
  44.  
  45.    SRGP_setWriteMode (WRITE_REPLACE);
  46.    SRGP_setClipRectangle
  47.       (SRGP_defRectangle
  48.      (0,0,
  49.       srgp__curActiveCanvasSpec.max_xcoord,
  50.       srgp__curActiveCanvasSpec.max_ycoord));
  51.  
  52.    SRGP_setFont (0);
  53.    SRGP_setLineStyle (CONTINUOUS);
  54.    SRGP_setLineWidth (1);
  55.    SRGP_setMarkerStyle (MARKER_CIRCLE);
  56.    SRGP_setMarkerSize (10);
  57.    SRGP_setFillStyle (SOLID);
  58.    SRGP_setPenStyle (SOLID);
  59.    SRGP_setFillBitmapPattern (0);
  60.    SRGP_setFillPixmapPattern (0);
  61.    SRGP_setPenBitmapPattern (0);
  62.    SRGP_setPenPixmapPattern (0);
  63.  
  64.    /* ERASE CANVAS MANUALLY. */
  65.    SRGP_setColor (0);
  66.    SRGP_fillRectangleCoord
  67.       (0,0,
  68.        srgp__curActiveCanvasSpec.max_xcoord,
  69.        srgp__curActiveCanvasSpec.max_ycoord);
  70.    SRGP_setColor (1);
  71.    SRGP_setBackgroundColor (0);
  72.  
  73.    /* MAKE SURE CHANGES GET INTO THE ACTUAL TABLE (not just in the cache) */
  74.    srgp__canvasTable[srgp__curActiveCanvasId] = srgp__curActiveCanvasSpec;
  75.  
  76.    POP_TRACE;
  77. }
  78.  
  79.  
  80.  
  81.  
  82. /*!*/
  83. void
  84. SRGP_useCanvas (canvasID canvas_id)
  85. {
  86.    DEBUG_AIDS{
  87.       SRGP_trace (SRGP_logStream, "SRGP_useCanvas: %d\n", canvas_id);
  88.       srgp_check_system_state();
  89.       srgp_check_extant_canvas(canvas_id);
  90.       LeaveIfNonFatalErr();
  91.    }
  92.  
  93.    /* UPDATE PERMANENT COPY OF SPEC FOR CURRENT ACTIVE CANVAS. */
  94.    srgp__canvasTable[srgp__curActiveCanvasId] = srgp__curActiveCanvasSpec;
  95.  
  96.    /* SET NEW ACTIVE, and LOAD CACHE. */
  97.    srgp__curActiveCanvasId = canvas_id;
  98.    srgp__curActiveCanvasSpec = srgp__canvasTable[srgp__curActiveCanvasId];
  99.  
  100. #ifdef THINK_C
  101.    SetPort (srgp__canvasTable[srgp__curActiveCanvasId].drawable.win);
  102. #endif
  103. }
  104.  
  105.  
  106.  
  107.  
  108. /*!*/
  109. canvasID
  110. SRGP_createCanvas (int width, int height)
  111. {
  112.    register int new_canvas_id;
  113.    boolean free_one_found;
  114.    canvas_spec *canvsptr;
  115.  
  116.    DEBUG_AIDS{
  117.       SRGP_trace (SRGP_logStream, "SRGP_createCanvas: %d %d\n", width, height);
  118.       srgp_check_system_state();
  119.       LeaveIfNonFatalErr();
  120.    }
  121.  
  122.    /* FIND AN EMPTY ENTRY IN CANVAS TABLE. */
  123.    new_canvas_id = 1;
  124.    free_one_found = FALSE;
  125.    while ((new_canvas_id <= MAX_CANVAS_INDEX) && !free_one_found)
  126.       if (srgp__canvasTable[new_canvas_id].drawable.bitmap != 0) 
  127.          new_canvas_id++;
  128.       else
  129.      free_one_found = TRUE;
  130.  
  131.    if (!free_one_found) {
  132.       SRGP__error (ERR_CANVAS_TABLE_FULL);
  133.       return (-1);
  134.    }
  135.  
  136.    /* ALL SYSTEMS ARE GO! */
  137.    canvsptr = &(srgp__canvasTable[new_canvas_id]);
  138.  
  139.    /* ALLOCATE THE BITMAP */
  140. #ifdef X11
  141.    if ( (canvsptr->drawable.bitmap =
  142.      XCreatePixmap (srgpx__display,
  143.             srgp__canvasTable[0].drawable.win,
  144.             width, height,
  145.             srgp__available_depth)) 
  146.                                         == 0) {
  147.       SRGP__error (ERR_MALLOC);
  148.       return (-1);
  149.    }
  150. #endif
  151.  
  152. #ifdef THINK_C
  153. #ifdef COLOR_QUICKDRAW
  154. {
  155.    CGrafPtr cgptr;
  156.    int depth, rowBytes;
  157.    long size;
  158.    Rect bounds;
  159.    Ptr myBits;
  160.    
  161.    SetRect (&bounds, 0, 0, width, height);
  162.    OpenCPort (cgptr = canvsptr->drawable.xid = 
  163.           (CGrafPtr)(NewPtr(sizeof(CGrafPort))));
  164.    depth = (**(*cgptr).portPixMap).pixelSize;
  165.    rowBytes = (((depth * width) + 15) >> 4) << 1;
  166.    size = (long) height * rowBytes;   
  167.    if ((myBits = NewPtr(size)) == NULL) {
  168.       SRGP__error (ERR_MALLOC);
  169.       return (-1);
  170.    }
  171.    (**(*cgptr).portPixMap).baseAddr = myBits;
  172.    (**(*cgptr).portPixMap).rowBytes = rowBytes + 0x8000;
  173.    (**(*cgptr).portPixMap).bounds = bounds;
  174. }
  175.  
  176. #else
  177.  
  178. {
  179.    GrafPtr cgptr;
  180.    int rowBytes;
  181.    long memreq;
  182.    Rect bounds;
  183.    BitMap newBitMap;
  184.    Ptr myBits;
  185.  
  186.    SetRect (&bounds, 0, 0, width, height);
  187.    OpenPort (cgptr = canvsptr->drawable.xid = 
  188.          (GrafPtr)(NewPtr(sizeof(GrafPort))));
  189.    newBitMap.rowBytes = (width>>3);
  190.    if ((width % 8) > 0)
  191.       newBitMap.rowBytes ++;
  192.    if ((rowBytes % 2) > 0) 
  193.       newBitMap.rowBytes++;
  194.    SetRect (&newBitMap.bounds, 0, 0, width, height);
  195.    memreq = newBitMap.rowBytes * height;
  196.    if ((newBitMap.baseAddr = NewPtr(memreq)) == NULL) {
  197.       SRGP__error (ERR_MALLOC);
  198.       return (-1);
  199.    }
  200.    else {
  201.       SetPortBits (&newBitMap);
  202.       thePort->portRect = newBitMap.bounds;
  203.    }
  204. }
  205. #endif
  206. #endif
  207.  
  208.    /* SET VARIOUS IMPORTANT FIELDS IN THE CANVAS SPEC. */
  209.    canvsptr->max_xcoord = width-1;
  210.    canvsptr->max_ycoord = height-1;
  211.  
  212.  
  213. #ifdef X11
  214.    canvsptr->gc_fill =
  215.       XCreateGC (srgpx__display, canvsptr->drawable.bitmap, 0L, NULL);
  216.    canvsptr->gc_frame =
  217.       XCreateGC (srgpx__display, canvsptr->drawable.bitmap, 0L, NULL);
  218. #endif
  219.  
  220.  
  221.    /* TELL THE WORLD TO PREPARE TO OUTPUT TO NEW BITMAP */
  222.    PUSH_TRACE;
  223.    SRGP_useCanvas (new_canvas_id);
  224.    SRGP__setCanvasDefaults();
  225.    POP_TRACE;
  226.  
  227.    return new_canvas_id;
  228. }
  229.  
  230.  
  231.  
  232.  
  233. /*!*/
  234. void
  235. SRGP_deleteCanvas (canvasID canvas_id)
  236. {
  237.    DEBUG_AIDS {
  238.       SRGP_trace (SRGP_logStream, "SRGP_deleteCanvas: %d\n", canvas_id);
  239.       srgp_check_system_state();
  240.       srgp_check_extant_canvas(canvas_id);
  241.       LeaveIfNonFatalErr();
  242.    }
  243.  
  244.    if (canvas_id == SCREEN_CANVAS)
  245.       SRGP__error (ERR_DELETION_OF_SCREEN);
  246.    if (canvas_id == srgp__curActiveCanvasId)
  247.       SRGP__error (ERR_DELETION_OF_ACTIVE_CANVAS);
  248.    LeaveIfNonFatalErr();
  249.  
  250. #ifdef X11
  251.    XFreePixmap (srgpx__display, srgp__canvasTable[canvas_id].drawable.bitmap);
  252. #endif
  253.  
  254. #ifdef THINK_C
  255. #ifdef COLOR_QUICKDRAW
  256. #  define canvasGrafport (*((CGrafPtr)(srgp__canvasTable[canvas_id].drawable.xid)))
  257.    DisposPtr ((**(canvasGrafport.portPixMap)).baseAddr);
  258. #else
  259. #  define canvasGrafport (*((GrafPtr)(srgp__canvasTable[canvas_id].drawable.xid)))
  260.    DisposPtr (canvasGrafport.portBits.baseAddr);
  261. #endif
  262.    ClosePort (srgp__canvasTable[canvas_id].drawable.xid);
  263.    DisposPtr (srgp__canvasTable[canvas_id].drawable.xid);
  264. #endif
  265.  
  266.    srgp__canvasTable[canvas_id].drawable.bitmap = 0; /* FREES THE TABLE ENTRY */
  267. }
  268.  
  269.